import api from './config'
import { getFallbackURL, buildFullURL } from '@/config/api-config'
import jsQR from 'jsqr'
import API_CONFIG from './apiConfig.js'
import logger from '../utils/logger.js'

// JWT令牌解析工具函数
function parseJWT(token) {
  try {
    logger.log('🔧 [JWT] parseJWT被调用...');
    
    if (!token || typeof token !== 'string') {
      logger.warn('⚠️ [JWT] 无效的令牌格式, token:', token, 'type:', typeof token);
      return null;
    }
    
    logger.log('🔧 [JWT] 令牌类型验证通过');
    
    // JWT格式: header.payload.signature
    const parts = token.split('.');
    logger.log('🔧 [JWT] 令牌分段数量:', parts.length);
    
    if (parts.length !== 3) {
      logger.warn('⚠️ [JWT] 令牌格式不正确，应为三段式，实际:', parts.length);
      logger.log('🔧 [JWT] 分段详情:', parts);
      return null;
    }
    
    // 解析payload部分（第二段）
    const payload = parts[1];
    
    // Base64URL解码
    // 先将Base64URL转换为标准Base64
    const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
    
    // 补齐padding
    const padded = base64 + '='.repeat((4 - base64.length % 4) % 4);
    
    // 解码
    const decoded = atob(padded);
    logger.log('🔧 [JWT] 解码后的JSON字符串:', decoded);
    
    // 在JSON解析前，先处理大数字问题
    // 使用正则表达式找到并替换大数字，将其包装为字符串
    let processedJson = decoded;
    
    // 匹配 "id":数字 的模式，特别处理19位数字
    const idPattern = /"id"\s*:\s*(\d{16,})/g;
    processedJson = processedJson.replace(idPattern, (match, number) => {
      logger.log(`🔧 [JWT] 发现大数字ID: ${number} (长度: ${number.length})`);
      return `"id":"${number}"`;  // 将数字转换为字符串
    });
    
    logger.log('🔧 [JWT] 处理后的JSON:', processedJson);
    
    // 现在安全地解析JSON
    const parsed = JSON.parse(processedJson);
    
    logger.log('✅ [JWT] 令牌解析成功:', parsed);
    return parsed;
    
  } catch (error) {
    logger.error('❌ [JWT] 令牌解析失败:', error);
    return null;
  }
}

// 测试大数字精度处理
function testLargeNumberHandling() {
  logger.log('🧪 [TEST] 测试JavaScript大数字精度问题:');
  
  // 使用真实的19位用户ID进行测试
  const realId = '1953810929896525824'; // 从JWT令牌中的实际ID
  logger.log('📋 [TEST] 真实19位ID:', realId);
  
  // 转换为数字会丢失精度
  const asNumber = Number(realId);
  logger.log('🔢 [TEST] 转为Number后:', asNumber);
  logger.log('❌ [TEST] 精度丢失:', String(asNumber) !== realId);
  logger.log('🔍 [TEST] 丢失的位数:', realId.length - String(asNumber).length);
  
  // 使用字符串保持精度
  const asString = String(realId);
  logger.log('📝 [TEST] 保持字符串:', asString);
  logger.log('✅ [TEST] 精度保持:', asString === realId);
  
  // 测试模拟JWT payload（模拟真实的JWT结构）
  const mockPayload = `{"claims":{"role":2,"id":${realId}},"exp":1755801200}`;
  logger.log('📋 [TEST] 模拟JWT payload:', mockPayload);
  
  try {
    const parsed = JSON.parse(mockPayload);
    logger.log('🔢 [TEST] 直接解析后的ID:', parsed.id);
    logger.log('❌ [TEST] 直接解析精度丢失:', String(parsed.id) !== realId);
    
    // 使用自定义解析器
    const parsedSafe = JSON.parse(mockPayload, (key, value) => {
      if (key === 'id' && typeof value === 'number' && value > Number.MAX_SAFE_INTEGER) {
        return String(value);
      }
      return value;
    });
    logger.log('📝 [TEST] 安全解析后的ID:', parsedSafe.id);
    logger.log('✅ [TEST] 安全解析精度保持:', parsedSafe.id === realId);
    
  } catch (error) {
    logger.error('❌ [TEST] 解析测试失败:', error);
  }
  
  logger.log('📊 [TEST] Number.MAX_SAFE_INTEGER:', Number.MAX_SAFE_INTEGER);
  logger.log('📏 [TEST] 最大安全整数位数:', String(Number.MAX_SAFE_INTEGER).length);
  logger.log('📏 [TEST] 实际ID位数:', realId.length);
}

// 从JWT令牌中获取用户ID
function getUserIdFromToken(token = null) {
  try {
    logger.log('🔍 [JWT] getUserIdFromToken被调用...');
    
    // 如果没有传入token，从localStorage获取
    const jwtToken = token || localStorage.getItem('token');
    
    if (!jwtToken) {
      logger.warn('⚠️ [JWT] 没有找到JWT令牌');
      logger.log('🔍 [JWT] localStorage.token =', localStorage.getItem('token'));
      return null;
    }
    
    logger.log('🔍 [JWT] 开始解析用户ID...');
    logger.log('🔑 [JWT] 令牌预览:', jwtToken.substring(0, 50) + '...');
    logger.log('🔑 [JWT] 令牌完整长度:', jwtToken.length);
    
    const payload = parseJWT(jwtToken);
    if (!payload) {
      logger.error('❌ [JWT] JWT解析失败');
      return null;
    }
    
    logger.log('✅ [JWT] JWT解析成功，payload:', payload);
    
    // 尝试从不同字段获取用户ID
    // 根据实际JWT结构，用户ID在 payload.claims.id 中
    let userId = null;
    
    // 首先检查 claims 对象中的 id
    if (payload.claims && payload.claims.id !== undefined) {
      userId = payload.claims.id;
      logger.log('✅ [JWT] 在payload.claims.id中找到用户ID');
    } 
    // 备用方案：检查根级别的字段
    else if (payload.id || payload.userId || payload.user_id || payload.sub) {
      userId = payload.id || payload.userId || payload.user_id || payload.sub;
      logger.log('✅ [JWT] 在根级别找到用户ID');
    }
    
    if (userId !== undefined && userId !== null) {
      // 重要：将用户ID转换为字符串以保持精度
      // JavaScript Number类型无法安全表示19位数字，必须使用字符串
      const userIdStr = String(userId);
      
      logger.log('✅ [JWT] 成功获取用户ID:', userIdStr);
      logger.log('🔢 [JWT] 用户ID类型:', typeof userId, '-> string');
      logger.log('📏 [JWT] 用户ID长度:', userIdStr.length, '位');
      logger.log('🔍 [JWT] 原始值:', userId);
      logger.log('🔍 [JWT] 字符串值:', userIdStr);
      
      // 如果是19位数字，特别提醒
      if (userIdStr.length >= 18) {
        logger.log('⚠️ [JWT] 检测到长数字ID，已转换为字符串保持精度');
      }
      
      return userIdStr;
    } else {
      logger.warn('⚠️ [JWT] 令牌中未找到用户ID字段');
      logger.log('🔍 [JWT] 可用字段:', Object.keys(payload));
      logger.log('🔍 [JWT] claims字段:', payload.claims ? Object.keys(payload.claims) : '不存在');
      return null;
    }
    
  } catch (error) {
    logger.error('❌ [JWT] 获取用户ID失败:', error);
    return null;
  }
}

// 导出测试函数
export { testLargeNumberHandling };

// 用户相关API
export const userApi = {
  // 用户登录 - 使用POST请求，数据作为请求体传递
  async login(data) {
    logger.log('🔗 [API] 调用登录验证API');
    
    // 智能显示日志 - 根据是否有密码字段决定显示内容
    const logData = {
      account: data.account,
      ...(data.password && { password: '****(已隐藏)' }),
      ...(data.code && { code: data.code })
    };
    
    logger.log('🔗 [API] 发送数据:', logData);
    logger.log('🔗 [API] 原始数据参数:', Object.keys(data));
    logger.log('🔗 [API] 数据将以请求体（body）方式发送');
    
    try {
      const response = await api.post('/goc/entry/login', data, { 
        timeout: 15000,  // 15秒超时
        skipAuth: true   // 登录接口跳过JWT令牌认证
      });
      
      logger.log('✅ [API] 后端验证完成，响应:', response);
      return response;
    } catch (error) {
      logger.error('❌ [API] 登录验证失败:', error.response?.data || error.message);
      throw error;
    }
  },

  // 用户注册 - 使用POST请求，数据作为Query参数传递
  async register(data) {
    logger.log('🔗 调用注册API，发送数据:', data);
    logger.log('📋 注册数据详情:', JSON.stringify(data, null, 2));
    
    // 构造后端期望的Query参数格式
    const queryParams = {
      userName: data.userName || data.username,  // 用户名
      account: data.account,                     // 账号（邮箱）
      password: data.password,                   // 密码
      code: data.code                           // 验证码
    };
    
    logger.log('🎯 使用后端期望的Query参数格式:', queryParams);
    logger.log('📋 Query参数详情:', JSON.stringify(queryParams, null, 2));
    
    try {
      // 使用后端期望的格式: POST + Query参数
      logger.log('🚀 使用POST + Query参数格式发送注册请求...');
      
      const response = await api.post('/goc/entry/register', null, { 
        params: queryParams,
        timeout: 15000,  // 15秒超时
        skipAuth: true   // 注册接口跳过JWT令牌认证
      });
      
      logger.log('✅ 注册API调用成功!', response);
      return response;
      
    } catch (error) {
      logger.error('❌ 注册API失败:', error);
      logger.error('❌ 错误详情:', {
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data,
        message: error.message
      });
      logger.error('❌ 发送的参数:', queryParams);
      throw error;
    }
  },

  // 更新用户信息
  updateUserInfo(data) {
    return api.put('/user/info', data)
  },

  // 修改密码 - 具体实现
  async changePassword(data) {
    logger.log('🔗 [API] 调用修改密码API');
    logger.log('🔗 [API] 发送数据:', {
      oldPassword: '****(已隐藏)',
      newPassword: '****(已隐藏)'
    });
    
    try {
      const response = await api.post('/goc/user/changePassword', null, { 
        params: {
          oldPassword: data.oldPassword,
          newPassword: data.newPassword
        },
        timeout: 15000  // 15秒超时
      });
      
      logger.log('✅ [API] 密码修改成功:', response);
      return response;
    } catch (error) {
      logger.error('❌ [API] 密码修改失败:', error.response?.data || error.message);
      logger.error('❌ [API] 错误详情:', {
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data
      });
      throw error;
    }
  },

  // 用户登出 - 调用后端接口归还JWT令牌
  async logout() {
    logger.error('🔥 [API-LOGOUT] userApi.logout方法被调用！');
    logger.log('🔗 [API] 调用退出登录API');
    
    // 检查JWT令牌是否存在
    const token = localStorage.getItem('token');
    logger.log('🔑 [API] 当前JWT令牌完整内容:', token);
    logger.log('🔑 [API] 令牌长度:', token ? token.length : 0);
    logger.log('🔑 [API] 是否包含Bearer前缀:', token ? token.startsWith('Bearer ') : false);
    
    if (!token) {
      logger.warn('⚠️ [API] 警告：没有JWT令牌，但仍然尝试调用退出API');
    } else {
      logger.log('🔑 [API] 令牌预览:', token.substring(0, 50) + '...');
    }
    
    try {
      logger.log('🚀 [API] 发送退出登录请求到: /api/goc/user/logout (通过代理)');
      logger.log('🔧 [API] 请求方式: GET');
      logger.log('🔧 [API] 当前环境:', process.env.NODE_ENV || 'development');
              logger.log('🔧 [API] 代理将转发到:', (api.defaults.baseURL || API_CONFIG.BASE_URL) + API_CONFIG.ENDPOINTS.USER_LOGOUT);
      logger.log('🔧 [API] JWT令牌将通过Authorization请求头自动传递');
      
      // 使用GET请求，JWT令牌通过拦截器自动添加到Headers
      // 根据后端要求和接口文档，测试不同的请求格式
      logger.log('🧪 [API] 尝试调用退出登录接口...');
      
      // 使用代理路径避免CORS问题
      const response = await api.get('/goc/user/logout', {
        timeout: 10000  // 10秒超时
        // JWT令牌会通过拦截器自动添加到Authorization头
      });
      
      logger.log('✅ [API] 退出登录成功，JWT令牌已归还:', response);
      return response;
    } catch (error) {
      logger.error('❌ [API] 退出登录失败:', error.response?.data || error.message);
      logger.error('❌ [API] 错误详情:', {
        status: error.response?.status,
        statusText: error.response?.statusText,
        headers: error.response?.headers,
        data: error.response?.data
      });
      // 即使退出接口失败，也应该清除本地令牌
      throw error;
    }
  },

  // 获取图像验证码 - 获取完整响应
  getCaptcha() {
    return api.get('/goc/entry/captcha', { 
      skipAuth: true  // 获取验证码接口跳过JWT令牌认证
    }).then(response => {
      // 这里response已经是response.data了（被拦截器处理过）
      logger.log('🔍 API返回的数据:', response);
      return response;
    }).catch(error => {
      logger.error('🚨 API请求失败:', error);
      throw error;
    });
  },





  // 发送邮箱验证码
  async sendEmailCode(data, onRetry = null) {
    logger.log('🔗 调用sendEmailCode API，数据:', data);
    logger.log('🔗 使用后端要求的参数格式: toEmail, captcha, captchaUuid');
    
    // 按照后端要求的格式构造参数
    const requestParams = {
      toEmail: data.toEmail || data.email,
      captcha: data.captcha || data.captchaCode || data.code,
      captchaUuid: data.captchaUuid || data.captchaId || data.uuid
    };
    
    logger.log('📧 发送的参数:', requestParams);
    logger.log('📧 参数详情:');
    logger.log('  - toEmail:', requestParams.toEmail);
    logger.log('  - captcha:', requestParams.captcha);
    logger.log('  - captchaUuid:', requestParams.captchaUuid);
    
    // 验证必需参数
    if (!requestParams.toEmail) {
      throw new Error('缺少邮箱地址 (toEmail)');
    }
    if (!requestParams.captcha) {
      throw new Error('缺少验证码 (captcha)');
    }
    if (!requestParams.captchaUuid) {
      throw new Error('缺少验证码UUID (captchaUuid)');
    }
    
    // 添加重试机制
    const maxRetries = 3;
    let lastError = null;
    
    for (let retry = 1; retry <= maxRetries; retry++) {
      try {
        logger.log(`🚀 发送邮箱验证码请求 (第${retry}次尝试)...`);
        logger.log('🔗 请求URL:', '/goc/entry/sendEmailCode');
        logger.log('📋 请求参数:', JSON.stringify(requestParams, null, 2));
        
            // 构造完整URL用于调试
        logger.log('🌐 目标接口: https://5b9ea05d.r20.vip.cpolar.cn/goc/entry/sendEmailCode');
        
        const response = await api.get('/goc/entry/sendEmailCode', { 
          params: requestParams,
          timeout: 30000,  // 30秒超时
          skipAuth: true   // 发送验证码接口跳过JWT令牌认证
        });
        
        logger.log('✅ 邮箱验证码API调用成功！');
        logger.log('📧 sendEmailCode API响应:', response);
        
        // 检查响应内容
        if (response && response.code === 1 && response.message === '图形验证码错误') {
          logger.warn('⚠️ 业务逻辑错误: 需要先验证图形验证码');
          const error = new Error('需要先验证图形验证码');
          error.isBusinessError = true;
          error.responseData = response;
          throw error;
        }
        
        return response;
        
      } catch (error) {
        lastError = error;
        logger.warn(`❌ 第${retry}次尝试失败:`, error.response?.status || error.message);
        
        // 如果是业务逻辑错误，不重试
        if (error.isBusinessError) {
          throw error;
        }
        
        // 如果不是最后一次尝试，等待后重试
        if (retry < maxRetries) {
          const waitTime = retry * 2000; // 2秒, 4秒, 6秒
          logger.log(`⏳ 等待${waitTime/1000}秒后重试...`);
          
          // 调用重试回调
          if (onRetry) {
            onRetry(retry);
          }
          
          await new Promise(resolve => setTimeout(resolve, waitTime));
        }
      }
    }
    
      // 所有重试都失败了
  logger.error('🚨 所有重试都失败了，最终错误:', lastError);
  throw lastError;
},

// 发送短信验证码
async sendSmsCode(phoneNumber) {
  logger.log('🔗 调用sendSmsCode API，手机号:', phoneNumber);
  
  try {
    const response = await api.post('/goc/entry/sendSmsCode', null, {
      params: { phone: phoneNumber },
      timeout: 15000
    });
    
    logger.log('✅ 短信验证码发送成功!', response);
    return response;
    
  } catch (error) {
    logger.error('❌ 短信验证码发送失败:', error);
    throw error;
  }
},

// 手机号登录
async phoneLogin(data) {
  logger.log('🔗 调用手机号登录API，数据:', data);
  
  try {
    const response = await api.post('/goc/entry/phoneLogin', null, {
      params: {
        phone: data.phone,
        code: data.code
      },
      timeout: 15000
    });
    
    logger.log('✅ 手机号登录成功!', response);
    return response;
    
  } catch (error) {
    logger.error('❌ 手机号登录失败:', error);
    throw error;
  }
},

// 账号密码登录（不需要验证码）
async accountLogin(data) {
  logger.log('🔗 调用账号密码登录API，数据:', data);
  logger.log('🔗 数据将以请求体（body）方式发送');
  
  try {
    // 使用和邮箱登录相同的接口，但不传验证码
    const response = await api.post('/goc/entry/login', {
      account: data.account,
      password: data.password
      // 不传code参数，表示账号密码登录
    }, {
      timeout: 15000,
      skipAuth: true   // 登录接口跳过JWT令牌认证
    });
    
    logger.log('✅ 账号密码登录成功!', response);
    return response;
    
  } catch (error) {
    logger.error('❌ 账号密码登录失败:', error);
    throw error;
  }
},

// 微信登录
async wechatLogin(authData) {
  logger.log('🔗 [API] 调用微信登录API');
  logger.log('🔗 [API] 授权数据:', authData);
  
  try {
    logger.log('🚀 [API] 发送微信登录请求...');
          const response = await api.post('/goc/WeChat/login', null, {
      params: authData,
      timeout: 15000
    });
    
    logger.log('✅ [API] 微信登录API调用成功');
    logger.log('📥 [API] 后端响应:', response);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 微信登录失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    });
    
    throw error;
  }
},

// 获取微信登录二维码
async getWechatQRCode() {
  logger.log('🔗 [API] 调用获取微信登录二维码API');
  
  try {
    logger.log('🚀 [API] 发送微信二维码获取请求...');
    
    // 设置为blob类型，用于接收图片数据
          const response = await api.get('/goc/WeChat/wxLogin', {
      timeout: 15000,  // 15秒超时
      responseType: 'blob',  // 明确设置为blob类型接收图片
      skipAuth: true  // 获取二维码不需要JWT令牌
    });
    
    logger.log('✅ [API] 微信二维码API调用成功');
    logger.log('📥 [API] 响应类型:', typeof response);
    logger.log('📥 [API] response.data类型:', typeof response.data);
    logger.log('📥 [API] 是否为Blob:', response.data instanceof Blob);
    logger.log('📥 [API] 响应大小:', response.data?.size || 'unknown');
    
    // 检查响应头中是否包含UUID信息
    const headers = response.headers || {};
    logger.log('📥 [API] 响应头:', headers);
    
    // 尝试从响应头中获取state/uuid
    let state = headers['x-wechat-state'] || headers['x-state'] || headers['state'];
    logger.log('🔍 [API] 从响应头获取的state:', state);
    
        // 如果响应数据是图片blob
    if (response.data instanceof Blob) {
      logger.log('📋 [API] 处理图片blob数据');
      
      const imageUrl = URL.createObjectURL(response.data);
      logger.log('📷 [API] 生成的图片URL:', imageUrl);
      
             try {
         // 使用jsQR库解析二维码内容
         logger.log('🔍 [API] 开始解析二维码内容...');
         
         // 创建Image对象来解析二维码
         const qrContent = await new Promise((resolve, reject) => {
           const img = new Image();
           img.crossOrigin = 'anonymous';
           
           img.onload = () => {
             try {
               logger.log('📷 [API] 图片加载完成，开始解码二维码');
               logger.log('📷 [API] 图片尺寸:', img.width, 'x', img.height);
               
               const canvas = document.createElement('canvas');
               const ctx = canvas.getContext('2d');
               canvas.width = img.width;
               canvas.height = img.height;
               ctx.drawImage(img, 0, 0);
               
               // 获取图像数据
               const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
               logger.log('📷 [API] 图像数据获取完成，像素数据长度:', imageData.data.length);
               
               // 使用jsQR解析
               logger.log('🔍 [API] 开始使用jsQR解析...');
               const qrResult = jsQR(imageData.data, imageData.width, imageData.height);
               
               if (qrResult) {
                 logger.log('✅ [API] 二维码解析成功:', qrResult);
                 logger.log('🔍 [API] 解析结果详情:', {
                   data: qrResult.data,
                   location: qrResult.location,
                   binaryData: qrResult.binaryData ? '存在' : '不存在'
                 });
                 resolve(qrResult.data);
               } else {
                 logger.error('❌ [API] jsQR未能识别二维码');
                 reject(new Error('未能识别二维码内容'));
               }
             } catch (error) {
               logger.error('❌ [API] 二维码解析过程出错:', error);
               reject(error);
             }
           };
           
           img.onerror = (error) => {
             logger.error('❌ [API] 图片加载失败:', error);
             logger.error('❌ [API] 可能的跨域或图片损坏问题');
             reject(error);
           };
           
           // 设置超时防止无限等待
           setTimeout(() => {
             reject(new Error('图片加载超时'));
           }, 10000);
           
           img.src = imageUrl;
         });
        
                 logger.log('🔍 [API] 二维码内容:', qrContent);
         logger.log('🔍 [API] 二维码内容类型:', typeof qrContent);
         logger.log('🔍 [API] 二维码内容长度:', qrContent?.length);
         
         // 从二维码内容中提取UUID/state
         let extractedState = null;
         if (qrContent) {
           logger.log('🔍 [API] 开始解析二维码内容...');
           
           // 尝试各种方式提取UUID
           if (typeof qrContent === 'string') {
             logger.log('🔍 [API] 二维码内容是字符串格式');
             
             // 情况1: 直接是UUID字符串
             if (qrContent.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)) {
               extractedState = qrContent;
               logger.log('🔑 [API] 二维码内容直接是UUID:', extractedState);
             }
             // 情况2: URL格式，包含state参数
             else if (qrContent.includes('state=')) {
               logger.log('🔍 [API] 检测到URL格式，查找state参数...');
               logger.log('🔍 [API] 完整URL:', qrContent);
               
               // 更精确的正则表达式来匹配state参数
               const stateMatch = qrContent.match(/[?&]state=([^&#]+)/);
               if (stateMatch) {
                 extractedState = decodeURIComponent(stateMatch[1]);
                 logger.log('🔑 [API] 从URL参数中提取state:', extractedState);
                 logger.log('🔑 [API] 原始匹配:', stateMatch[1]);
                 logger.log('🔑 [API] 解码后:', extractedState);
               } else {
                 logger.error('❌ [API] 未能在URL中找到state参数');
                 logger.log('🔍 [API] 尝试其他匹配方式...');
                 
                 // 尝试更宽松的匹配
                 const fallbackMatch = qrContent.match(/state=([^&\s#]+)/);
                 if (fallbackMatch) {
                   extractedState = decodeURIComponent(fallbackMatch[1]);
                   logger.log('🔑 [API] 使用fallback匹配到state:', extractedState);
                 }
               }
             }
             // 情况3: JSON字符串
             else {
               logger.log('🔍 [API] 尝试作为JSON解析...');
               try {
                 const parsed = JSON.parse(qrContent);
                 extractedState = parsed.state || parsed.uuid;
                 logger.log('🔑 [API] 从JSON中提取state:', extractedState);
               } catch (e) {
                 logger.log('⚠️ [API] 二维码内容不是JSON格式:', e.message);
               }
             }
           } else {
             logger.log('⚠️ [API] 二维码内容不是字符串格式:', typeof qrContent);
           }
         } else {
           logger.error('❌ [API] 二维码内容为空');
         }
         
         logger.log('🔍 [API] 最终提取的state:', extractedState);
        
        // 使用解析出的state，如果没有则使用响应头或生成
        state = extractedState || state;
        
        if (!state) {
          logger.log('⚠️ [API] 未能从二维码中提取UUID，生成新的UUID');
          // 生成UUID作为fallback
          if (window.crypto && window.crypto.randomUUID) {
            state = window.crypto.randomUUID();
            logger.log('🔑 [API] 生成的UUID:', state);
          } else {
            state = 'uuid-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
            logger.log('🔑 [API] fallback UUID:', state);
          }
        } else {
          logger.log('✅ [API] 成功提取UUID:', state);
        }
        
             } catch (qrError) {
         logger.error('❌ [API] 二维码解析过程出错:', qrError);
         logger.error('❌ [API] 错误详情:', {
           name: qrError.name,
           message: qrError.message,
           stack: qrError.stack
         });
         
         // 如果二维码解析失败，检查是否有从响应头获取的state
         if (!state) {
           logger.warn('⚠️ [API] 二维码解析失败且无响应头state，生成fallback UUID');
           if (window.crypto && window.crypto.randomUUID) {
             state = window.crypto.randomUUID();
             logger.log('🔑 [API] 二维码解析失败，生成UUID:', state);
           } else {
             state = 'uuid-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
             logger.log('🔑 [API] 二维码解析失败，使用fallback UUID:', state);
           }
         } else {
           logger.log('🔑 [API] 二维码解析失败，但使用响应头中的state:', state);
         }
       }
      
      return {
        data: {
          qrCodeUrl: imageUrl,
          qrCode: imageUrl, // 兼容性
          state: state,
          uuid: state
        }
      };
    }
    
    // 如果不是blob，尝试作为JSON处理
    logger.log('📋 [API] 尝试作为JSON处理');
    logger.log('📥 [API] 响应数据:', response);
    
    if (response && typeof response === 'object') {
      return {
        data: {
          ...response,
          state: response.state || response.uuid || state,
          uuid: response.state || response.uuid || state
        }
      };
    }
    
    // 兜底处理
    logger.log('⚠️ [API] 使用兜底处理');
    return {
      data: {
        qrCodeUrl: null,
        state: state || Date.now().toString(),
        uuid: state || Date.now().toString(),
        error: '无法解析二维码数据'
      }
    };
    
  } catch (error) {
    logger.error('❌ [API] 微信二维码获取失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message,
      headers: error.response?.headers
    });
    
    throw error;
  }
},

// 获取微信二维码状态（新接口）
async getWechatState(uuid) {
  logger.log('🔗 [API] 获取微信二维码状态, uuid:', uuid);
  
    try {
        // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.WECHAT_GET_STATE}?state=${uuid}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    logger.log('🌐 [API] 请求参数:', { state: uuid });
    
    // 调用正确的微信状态获取接口
    const response = await api.get('/goc/WeChat/getState', {
      params: { state: uuid },
      timeout: 10000,
      skipAuth: true  // 获取状态不需要JWT令牌
    });
    
    logger.log('✅ [API] 微信状态获取成功');
    logger.log('📥 [API] 原始响应:', response);
    logger.log('🔍 [API] 响应详细分析:', {
      'response类型': typeof response,
      'response.code': response?.code,
      'response.message': response?.message,
      'response.data': response?.data,
      'response.data类型': typeof response?.data,
      'response.data内容': response?.data
    });
    
    // 根据后端返回规则处理响应
    let processedResponse = null;
    
    if (response) {
      // 情况1: 用户已扫码 - 返回JWT令牌
      if (response.data && typeof response.data === 'string' && response.data.startsWith('eyJ')) {
        logger.log('🎉 [API] 检测到JWT令牌 - 用户已扫码并确认登录');
        logger.log('🔑 [API] JWT令牌预览:', response.data.substring(0, 50) + '...');
        processedResponse = {
          status: 'success',
          token: response.data,
          message: '登录成功'
        };
      }
      // 情况2: 用户未扫码 - 返回"未登录"
      else if (response.data === '未登录' || 
               (response.message && response.message.includes('未登录')) ||
               (response.data && response.data.includes && response.data.includes('未登录'))) {
        logger.log('⏳ [API] 用户未扫码 - 继续等待');
        processedResponse = {
          status: 'waiting',
          message: '等待用户扫码'
        };
      }
      // 情况3: 二维码过期 - 返回null或空
      else if (response.data === null || 
               response.data === undefined || 
               response.data === '' ||
               (response.code && response.code !== 0)) {
        logger.log('⏰ [API] 二维码可能已过期');
        processedResponse = {
          status: 'expired',
          message: '二维码已过期'
        };
      }
      // 其他情况 - 继续等待
      else {
        logger.log('⏳ [API] 未明确状态，继续等待');
        logger.log('🔍 [API] 当前响应数据:', response.data);
        processedResponse = {
          status: 'waiting',
          message: '等待用户扫码',
          rawData: response.data
        };
      }
    } else {
      processedResponse = {
        status: 'waiting',
        message: '等待响应'
      };
    }
    
    logger.log('🔍 [API] 处理后的状态:', processedResponse);
    return processedResponse;
    
  } catch (error) {
    logger.error('❌ [API] 微信状态获取失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    });
    
    // 网络错误或其他错误，返回等待状态继续轮询
    if (error.response?.status === 404 || error.code === 'NETWORK_ERROR') {
      logger.log('⚠️ [API] 网络错误或接口不存在，返回等待状态');
      return {
        status: 'waiting',
        message: '网络错误，继续重试'
      };
    }
    
    // 其他错误抛出
    throw error;
  }
},

// 检查微信扫码状态（保留原接口作为备用）
async checkWechatStatus(state) {
  logger.log('🔗 [API] 检查微信扫码状态, state:', state);
  
  try {
    // 调用后端微信状态检查接口
    const response = await api.get('/goc/WeChat/checkStatus', {
      params: { state },
      timeout: 5000
    });
    
    logger.log('✅ [API] 微信状态检查成功');
    logger.log('📥 [API] 状态响应:', response);
    logger.log('🔍 [API] 响应结构分析:', {
      'response.code': response?.code,
      'response.message': response?.message,
      'response.data': response?.data,
      'response.data类型': typeof response?.data,
      '是否JWT令牌': response?.data && typeof response.data === 'string' && response.data.startsWith('eyJ')
    });
    
    // 检查是否直接返回了JWT令牌（登录成功）
    if (response && response.code === 0 && response.data && typeof response.data === 'string' && response.data.startsWith('eyJ')) {
      logger.log('🎉 [API] 检测到微信登录成功，后端直接返回JWT令牌');
      logger.log('🔑 [API] JWT令牌:', response.data.substring(0, 50) + '...');
    }
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 微信状态检查失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    });
    
    // 如果接口不存在（404），返回等待状态，让前端继续轮询
    if (error.response?.status === 404) {
      logger.log('⚠️ [API] 微信状态检查接口不存在，返回等待状态');
      return {
        data: {
          status: 'waiting'
        }
      };
    }
    
    throw error;
  }
},

// 检查微信二维码状态 - 按后端规范实现
async checkWechatQRStatus(uuid) {
  logger.log('🔗 [API] 检查微信二维码状态 (后端规范), uuid:', uuid);
  
    try {
        // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.WECHAT_CHECK_STATUS}?state=${uuid}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    logger.log('🌐 [API] 请求参数:', { state: uuid });
    logger.log('🌐 [API] 当前环境:', process.env.NODE_ENV);
    logger.log('🌐 [API] 使用的baseURL:', baseURL);
    
    // 按照后端要求：将state作为参数名，uuid作为参数值传入
    // 注意：微信状态检查接口可能不需要JWT令牌认证
    const response = await api.get('/goc/WeChat/checkStatus', {
      params: { state: uuid },
      timeout: 15000, // 增加超时时间到15秒
      headers: {
        'Accept': 'application/json, text/plain, */*',
        // 明确不包含Authorization头，因为这是获取令牌前的状态检查
      },
      // 跳过axios拦截器中的JWT令牌添加逻辑
      skipAuth: true
    });
    
    logger.log('✅ [API] 微信状态检查响应:', response);
    logger.log('🔍 [API] 响应详细分析:', {
      'response类型': typeof response,
      'response.code': response?.code,
      'response.message': response?.message,
      'response.data': response?.data,
      'response.data类型': typeof response?.data,
      '是否为JWT令牌': response?.data && typeof response.data === 'string' && response.data.length > 100
    });
    
    // 按照后端精确规范处理响应
    let processedResponse = null;
    
    logger.log('🔍 [API] 原始完整响应:', JSON.stringify(response, null, 2));
    logger.log('🔍 [API] response.data详细信息:', {
      value: response.data,
      type: typeof response.data,
      isNull: response.data === null,
      isUndefined: response.data === undefined,
      length: response.data?.length,
      stringValue: String(response.data)
    });
    
    // 按照后端说明的三种情况精确处理：
    
    // 情况1: 用户已扫码 - 返回JWT令牌
    if (response.data && typeof response.data === 'string' && response.data !== '未登录') {
      // 检查是否是有效的令牌（不是"未登录"字符串的任何其他字符串都认为是令牌）
      logger.log('🎉 [API] 用户已扫码 - 收到令牌');
      logger.log('🔑 [API] 令牌内容:', response.data);
      logger.log('🔑 [API] 令牌长度:', response.data.length);
      logger.log('🔑 [API] 令牌前50字符:', response.data.substring(0, 50));
      
      processedResponse = {
        status: 'success',
        token: response.data,
        message: '用户已扫码，登录成功'
      };
    }
    // 情况2: 用户未扫码 - 返回"未登录"
    else if (response.data === '未登录') {
      logger.log('⏳ [API] 用户未扫码 - 返回"未登录"');
      processedResponse = {
        status: 'waiting',
        message: '用户未扫码，等待扫码'
      };
    }
    // 情况3: 二维码过期 - 什么也不传回（null或undefined）
    else if (response.data === null || response.data === undefined) {
      logger.log('⏰ [API] 二维码过期 - 返回null/undefined');
      processedResponse = {
        status: 'expired',
        message: '二维码已过期'
      };
    }
    // 其他情况（空字符串等）
    else {
      logger.log('🔍 [API] 其他情况，原始数据:', response.data);
      logger.log('🔍 [API] 数据类型:', typeof response.data);
      logger.log('🔍 [API] 数据值:', JSON.stringify(response.data));
      
      // 空字符串或其他意外值，继续等待
      processedResponse = {
        status: 'waiting',
        message: '收到意外响应，继续等待',
        rawData: response.data
      };
    }
    
    logger.log('🔍 [API] 最终处理状态:', processedResponse);
    return processedResponse;
    
  } catch (error) {
    logger.error('❌ [API] 微信状态检查失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message,
      code: error.code,
      config: {
        url: error.config?.url,
        method: error.config?.method,
        params: error.config?.params,
        baseURL: error.config?.baseURL
      }
    });
    
    // 详细分析错误类型
    if (error.code === 'ECONNABORTED') {
      logger.log('⏰ [API] 请求超时');
      return {
        status: 'waiting',
        message: '请求超时，继续重试'
      };
    } else if (error.code === 'ERR_NETWORK') {
      logger.log('🌐 [API] 网络连接错误');
      return {
        status: 'waiting',
        message: '网络连接错误，继续重试'
      };
         } else if (error.response?.status === 401) {
       logger.log('🔐 [API] 微信状态检查接口返回401 - 可能需要认证或接口有问题');
       logger.log('🔐 [API] 响应数据:', error.response?.data);
       return {
         status: 'waiting',
         message: '认证问题，继续重试'
       };
     } else if (error.response?.status === 404) {
       logger.log('⚠️ [API] 状态检查接口不存在(404)');
       return {
         status: 'error',
         message: '状态检查接口不存在'
       };
     } else if (error.response?.status >= 500) {
      logger.log('⚠️ [API] 服务器错误，继续重试');
      return {
        status: 'waiting',
        message: '服务器错误，继续重试'
      };
    } else if (error.response?.status === 0) {
      logger.log('🚫 [API] 代理或CORS错误');
      return {
        status: 'waiting',
        message: '代理错误，继续重试'
      };
    } else {
      logger.log('❓ [API] 未知错误，继续重试');
      return {
        status: 'waiting',
        message: `未知错误(${error.message})，继续重试`
      };
    }
  }
},

// 通过OpenID获取微信用户信息
async getWechatUserInfoByOpenid() {
  logger.log('🔗 [API] 获取微信用户信息 (通过OpenID)');
  
  // 检查JWT令牌
  const token = localStorage.getItem('token');
  logger.log('🔑 [API] 当前JWT令牌状态:', token ? `有令牌(${token.length}字符)` : '无令牌');
  logger.log('🔑 [API] JWT令牌预览:', token ? token.substring(0, 50) + '...' : 'null');
  
  try {
    // 使用代理路径避免CORS问题
              logger.log('🌐 [API] 使用代理路径: /api/goc/WeChatUser/getUserInfoByOpenid');
        logger.log('🌐 [API] 代理将转发到:', `${api.defaults.baseURL || API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.WECHAT_GET_USER_INFO}`);
    logger.log('🌐 [API] 请求方法: GET');
    
    // 尝试使用代理路径避免CORS问题
    const response = await api.get('/goc/WeChatUser/getUserInfoByOpenid', {
      timeout: 10000,
      // 这个接口需要JWT令牌认证，令牌会由axios拦截器自动添加
      headers: {
        'Accept': 'application/json'
      }
    });
    
    logger.log('✅ [API] 微信用户信息获取成功');
    logger.log('📥 [API] 用户信息响应:', response);
    logger.log('🔍 [API] 用户信息详情:', {
      'response类型': typeof response,
      'response.code': response?.code,
      'response.message': response?.message,
      'response.data': response?.data,
      'data类型': typeof response?.data
    });
    
    // 检查响应格式
    if (response && response.data) {
      logger.log('👤 [API] 用户头像:', response.data.avatar || response.data.headimgurl);
      logger.log('👤 [API] 用户昵称:', response.data.nickname || response.data.username);
    }
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 微信用户信息获取失败:', error);
    logger.error('❌ [API] 错误详情:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    });
    
    // 对于用户信息获取失败，不阻止登录流程
    if (error.response?.status === 401) {
      logger.log('🔐 [API] JWT令牌无效或过期');
    } else if (error.response?.status === 404) {
      logger.log('⚠️ [API] 用户信息接口不存在');
    } else if (error.code === 'ERR_NETWORK' && error.message === 'Network Error') {
      logger.log('🌐 [API] CORS或网络错误 - 这可能是后端CORS配置问题');
      logger.log('🛠️ [API] 建议检查后端 /goc/WeChatUser/getUserInfoByOpenid 接口的CORS配置');
      
      // 尝试备用GET请求（简化请求头）
      try {
        logger.log('🔄 [API] 尝试备用GET请求...');
        const backupResponse = await api.get('/goc/WeChatUser/getUserInfoByOpenid', {
          timeout: 10000,
          headers: {
            'Accept': 'application/json'
          }
        });
        
        logger.log('✅ [API] 备用GET请求成功');
        return backupResponse;
      } catch (backupError) {
        logger.error('❌ [API] 备用GET请求也失败:', backupError.message);
        
        // 最后尝试：使用原生fetch，完全避免axios默认配置
        try {
          logger.log('🔄 [API] 尝试原生fetch请求...');
          const token = localStorage.getItem('token');
          const fetchResponse = await fetch('/goc/WeChatUser/getUserInfoByOpenid', {
            method: 'GET',
            headers: {
              'Authorization': token,
              'Accept': 'application/json'
            }
          });
          
          if (fetchResponse.ok) {
            const data = await fetchResponse.json();
            logger.log('✅ [API] 原生fetch请求成功');
            return data;
          } else {
            logger.error('❌ [API] 原生fetch请求状态错误:', fetchResponse.status);
          }
        } catch (fetchError) {
          logger.error('❌ [API] 原生fetch请求也失败:', fetchError.message);
        }
      }
    }
    
    throw error;
  }
},

// 获取用户详细信息
async getUserProfile() {
  try {
    logger.log('🔍 [API] 开始获取用户详细信息...')
    
    const response = await api.get('/goc/user/profile')
    
    logger.log('✅ [API] 用户详细信息获取成功:', response)
    return response
    
  } catch (error) {
    logger.error('❌ [API] 获取用户详细信息失败:', error)
    throw error
  }
},

// 更新用户信息
async updateUserProfile(userInfo) {
  try {
    logger.log('💾 [API] 开始更新用户信息...')
    logger.log('📤 [API] 提交的用户信息:', userInfo)
    
    const response = await api.put('/goc/user/profile', userInfo)
    
    logger.log('✅ [API] 用户信息更新成功:', response)
    return response
    
  } catch (error) {
    logger.error('❌ [API] 更新用户信息失败:', error)
    throw error
  }
},

// 更新用户完整信息（通过updateIdentityCard接口）
async updateUserCompleteInfo(userInfo) {
  logger.log('👤 [API] 更新用户完整信息:', userInfo);
  
  try {
    // 构建Query参数
    const params = {};
    
    // 根据接口文档，昵称字段为userName
    if (userInfo.nickname) params.userName = userInfo.nickname;
    if (userInfo.gender) params.sex = userInfo.gender; // 性别字段为sex
    if (userInfo.address) params.address = userInfo.address;
    if (userInfo.workplace) params.unit = userInfo.workplace; // 工作单位字段为unit
    if (userInfo.identity) params.grade = userInfo.identity; // 身份字段为grade
    if (userInfo.introduction) params.userIntroduction = userInfo.introduction;
    if (userInfo.idCard) params.identityCard = userInfo.idCard; // 身份证字段为identityCard
    
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const queryString = Object.keys(params).map(key => `${key}=${encodeURIComponent(params[key])}`).join('&');
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.USER_UPDATE_IDENTITY}?${queryString}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    logger.log('🌐 [API] 请求参数:', params);
    
    // 使用POST请求，参数通过Query传递
    const response = await api.post('/goc/user/updateIdentityCard', null, {
      params: params
    });
    
    logger.log('✅ [API] 用户信息更新成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 更新用户信息失败:', error);
    
    // 详细的错误信息
    if (error.response) {
      logger.error('📊 [API] 错误状态码:', error.response.status);
      logger.error('📋 [API] 错误响应数据:', error.response.data);
    } else if (error.request) {
      logger.error('🌐 [API] 请求未收到响应:', error.request);
    } else {
      logger.error('⚙️ [API] 请求配置错误:', error.message);
    }
    
    throw error;
  }
},


// 更新用户密码
async updatePassword(oldPassword, newPassword) {
  logger.log('🔑 [API] 调用更新密码API');
  logger.log('🔑 [API] 旧密码长度:', oldPassword ? oldPassword.length : 0);
  logger.log('🔑 [API] 新密码长度:', newPassword ? newPassword.length : 0);
  
  try {
    const response = await api.post('/goc/user/updatePassword', null, {
      params: {
        oldPassword: oldPassword,
        password: newPassword
      },
      timeout: 10000  // 10秒超时
    });
    
    logger.log('✅ [API] 密码更新响应:', response);
    return response;
  } catch (error) {
    logger.error('❌ [API] 密码更新失败:', error.response?.data || error.message);
    throw error;
  }
},

// 获取用户首页信息（根据JWT令牌中的用户ID）
async getUserHomeInfo(userId = null) {
  try {
    logger.log('🔍 [API] 开始获取用户首页信息...');
    
    // 如果没有传入userId，尝试从JWT令牌中解析
    let targetUserId = userId;
    if (!targetUserId) {
      targetUserId = getUserIdFromToken();
      if (!targetUserId) {
        throw new Error('无法获取用户ID，请确保已登录');
      }
    }
    
    logger.log('🆔 [API] 目标用户ID:', targetUserId);
    logger.log('🔢 [API] 用户ID类型:', typeof targetUserId);
    logger.log('📏 [API] 用户ID长度:', String(targetUserId).length, '位');
    logger.log('🌐 [API] 调用接口: GET /api/goc/user/userHomeInfo');
    logger.log('📋 [API] Query参数: { id:', targetUserId, '}');
    
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.USER_INFO}?id=${targetUserId}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    
    // 调用API获取用户信息
    const response = await api.get('/goc/user/userHomeInfo', {
      params: {
        id: targetUserId
      },
      timeout: 15000  // 15秒超时
    });
    
    logger.log('✅ [API] 用户首页信息获取成功:', response);
    
    // 检查响应数据
    if (response && response.data) {
      logger.log('📋 [API] 用户首页信息详情:', response.data);
      return response;
    } else {
      logger.warn('⚠️ [API] 响应数据为空或格式异常');
      return response;
    }
    
  } catch (error) {
    logger.error('❌ [API] 获取用户首页信息失败:', error);
    
    // 详细的错误信息
    if (error.response) {
      logger.error('📊 [API] 错误状态码:', error.response.status);
      logger.error('📋 [API] 错误响应数据:', error.response.data);
      logger.error('📝 [API] 错误响应头:', error.response.headers);
    } else if (error.request) {
      logger.error('🌐 [API] 请求未收到响应:', error.request);
    } else {
      logger.error('⚙️ [API] 请求配置错误:', error.message);
    }
    
    throw error;
  }
},

// 别名方法：向后兼容
async getUserInfoById(userId = null) {
  logger.log('⚠️ [API] getUserInfoById已废弃，请使用getUserHomeInfo');
  return this.getUserHomeInfo(userId);
},

// 更新身份证信息
async updateIdentityCard(identityCard) {
  logger.log('🆔 [API] 更新身份证信息, identityCard:', identityCard);
  
  try {
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.USER_UPDATE_IDENTITY}?identityCard=${encodeURIComponent(identityCard)}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    logger.log('🌐 [API] 请求参数:', { identityCard });
    
    // 使用POST请求，参数通过Query传递
    const response = await api.post('/goc/user/updateIdentityCard', null, {
      params: {
        identityCard: identityCard
      }
    });
    
    logger.log('✅ [API] 身份证更新成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 更新身份证失败:', error);
    
    // 详细的错误信息
    if (error.response) {
      logger.error('📊 [API] 错误状态码:', error.response.status);
      logger.error('📋 [API] 错误响应数据:', error.response.data);
    } else if (error.request) {
      logger.error('🌐 [API] 请求未收到响应:', error.request);
    } else {
      logger.error('⚙️ [API] 请求配置错误:', error.message);
    }
    
    throw error;
  }
},

// 更新手机号或邮箱信息
async updatePhoneOrEmail(phone, email) {
  logger.log('📞 [API] 更新手机号或邮箱信息, phone:', phone, 'email:', email);
  
  try {
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const queryParams = [];
    if (phone) queryParams.push(`phone=${encodeURIComponent(phone)}`);
    if (email) queryParams.push(`email=${encodeURIComponent(email)}`);
    const queryString = queryParams.join('&');
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.USER_UPDATE_PHONE_EMAIL}?${queryString}`;
    logger.log('🌐 [API] 代理将转发到:', fullURL);
    logger.log('🌐 [API] 请求参数:', { phone, email });
    
    // 使用POST请求，参数通过Query传递
    const response = await api.post('/goc/user/updatePhoneOrEmail', null, {
      params: {
        phone: phone,
        email: email
      }
    });
    
    logger.log('✅ [API] 手机号/邮箱更新成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 更新手机号/邮箱失败:', error);
    
    // 详细的错误信息
    if (error.response) {
      logger.error('📊 [API] 错误状态码:', error.response.status);
      logger.error('📋 [API] 错误响应数据:', error.response.data);
    } else if (error.request) {
      logger.error('🌐 [API] 请求未收到响应:', error.request);
    } else {
      logger.error('⚙️ [API] 请求配置错误:', error.message);
    }
    
    throw error;
  }
},

  /**
   * 批量创建学生账号
   * @param {Array} students - 学生信息数组
   * @returns {Promise}
   */
  async batchCreateStudents(students) {
    logger.log('👥 [API] 调用批量创建学生账号接口')
    logger.log('📝 [API] 学生数量:', students.length)
    logger.log('🌐 [API] 接口地址:', API_CONFIG.getFullURL('/goc/user/batchCreate'))
    
    try {
      const response = await api.post('/goc/user/batchCreate', students, {
        timeout: 30000  // 30秒超时，因为批量操作可能需要更长时间
      })
      
      logger.log('✅ [API] 批量创建学生账号成功:', response)
      return response
      
    } catch (error) {
      logger.error('❌ [API] 批量创建学生账号失败:', error)
      logger.error('📊 [API] 错误详情:', {
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data
      })
      throw error
    }
  }
} 